﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.IO;
using System.Xml;
using System.Runtime.Serialization.Formatters.Binary;

namespace EntitiesLayer
{

    /// <summary>
    /// 
    /// </summary>
    [Serializable]
    [XmlRoot(ElementName = "BatchImporter", IsNullable = false)]
    public class BatchImporter_Fields
    {
        [XmlElement("Tarea")]
        public List<Camara> camaras = new List<Camara>();

        /// <summary>
        /// Método que permite la serialización de un tipo de clase hacia un Archivo XML
        /// </summary>
        /// <typeparam name="T">Clase a serializar.</typeparam>
        /// <param name="objSerilizable">Objeto del tipo de clase.</param>
        /// <param name="direccionArchivo">Dirección física en donde se almacenará el archivo XML.</param>
        public static bool XmlSerializarArchivo<T>(T objSerilizable, string direccionArchivo) where T : class, new()
        {
            try
            {
                //create an empty namespace
                var ns = new XmlSerializerNamespaces();
                ns.Add("", "");

                using (Stream stream = File.Open(direccionArchivo, FileMode.Create))
                {
                    var serializer = new XmlSerializer(typeof(T));
                    serializer.Serialize(stream, objSerilizable, ns);
                    stream.Close();
                }
                return true;
            }
            catch (Exception exc)
            {
                return false;
            }
        }

        /// <summary>
        /// Método que permite la deserialización de un archivo XML a un tipo de Objeto.
        /// </summary>
        /// <typeparam name="T">Clase a la cual se va a deserializar.</typeparam>
        /// <param name="xmlContent">Dirección en disco del Archivo XML</param>
        /// <returns></returns>
        public static T Deserializar<T>(string xmlContent) where T : class, new()
        {
            try
            {
                var xDoc = new XmlDocument();
                xDoc.Load(xmlContent);
                var objInstanciado = new T();
                TextReader varTxtLectura = new StringReader(xDoc.OuterXml);
                var varDeserializador = new XmlSerializer(objInstanciado.GetType());
                objInstanciado = (T)varDeserializador.Deserialize(varTxtLectura);
                varTxtLectura.Close();
                return objInstanciado;
            }
            catch (Exception exc)
            {
                return null;
            }
        }


        /// <summary>
        /// Método que permite la busqueda de un cámara de acuerdo a su código identificador.
        /// </summary>
        /// <param name="idCamara">Identificar de la cámara a buscar.</param>
        /// <returns>Camara con las propiedades correspondientes a las de la busqueda.</returns>
        public Camara BuscarCamara(string idCamara)
        {
            try
            {
                foreach (Camara camara in camaras)
                    if (camara.identificador.Equals(idCamara))
                        return camara;

                return null;
            }
            catch (Exception exc)
            {
                return null;
            }

        }


        /// <summary>
        /// Método que permite la busqueda de un cámara de acuerdo a su código identificador. 
        /// </summary>
        /// <param name="codigBusqueda">Código correspondiente a la camara.</param>
        /// <param name="cantidadCampos">Cantidad de campos configurado para la camara.</param>
        /// <returns></returns>
        public Camara BuscarCamara(string codigBusqueda, int cantidadCampos)
        {
            try
            {
                foreach (Camara camara in camaras)
                    if (camara.codigoCheque.Equals(codigBusqueda) && camara.cantidadCampos == cantidadCampos)
                        return camara;
                return null;
            }
            catch (Exception exc)
            {
                return null;
            }

        }

        /// <summary>
        /// Método que permite Clonar un Objeto respaldando los datos contenidos
        /// </summary>
        /// <typeparam name="T">Tipo del Objeto a crear.</typeparam>
        /// <param name="obj">Objeto a clonar.</param>
        /// <returns>Objeto clonado.</returns>
        public static object ClonacionAnidada<T>(T obj)
        {
            try
            {
                if (obj == null)
                {
                    return null;
                }
                else
                {
                    using (var ms = new MemoryStream())
                    {
                        var formatter = new BinaryFormatter();
                        formatter.Serialize(ms, obj);
                        ms.Position = 0;

                        return (T)formatter.Deserialize(ms);
                    }
                }
            }
            catch (Exception exc)
            {
                return null;
            }

        }

    }
}
